Java Syntax und Schlüsselworte
==============================

public - im Augenblick ein Zauberspruch

class - ... Eine Art Sammlung von Funktionen ...
        - Jede Klasse braucht einen Namen
        - Klasse muss in eigener Datei stehen
        - Datei muss so heißen wie der Klassenname
        - Klassennamen werde *groß* geschrieben
          - BEACHTEN: der Dateiname deshalb auch!
        - Alle Klassen bei uns sind _public_
          - Details würden "die Bevölkerung verunsichern" :-)
          
Funktionen
----------
Zauberspruch
  public static  rückgabetyp  Name( argumente )

  - Synonym: Methode  
  - Programm beginnt bei einer Funktion namens main()
    - per Festlegung!
    - main Funktion nimmt ein String Array entgegen
    - main Funktion gibt  void  zurück

  Daher:
  public static void main(String arg[])
  
  - Wir können beliebige eigene Funktionen definieren
  - Alle Funktionen gehören zu einer Klasse, immer!
  - Funktion darf genau einen Wert zurück geben
    - darf  void  sein
    - darf ein Array sein
  - Funktion nimmt beim Aufruf Argumente / Parameter
    entgegen
    - (das, was in den Klammern steht)
  
  Beispiel:
  // Deklaration einer Funktion
  public static String raute( int n, String w ) {
    //          |       |     |      ^ bekommt String als Argument
    //          |       |     ^ bekommt int als Argument
    //          |       ^ Hat den Namen "raute"
    //          ^ Wird evaluiert zu String
    
Variablen:
----------
- Enthalten einen Wert
  - überall im Programm, wo nur ein Variablenname steht,
    wird der Wert dieser Variable eingesetzt
    ("Evaluation" / "Auswertung")

- haben in Java einen Typ
  primitive Datentypen:
    int, double, float, boolean, byte, ...
  komplexe Datentypen:
    String, ... alles andere
  
  komplexe Objekte haben Methoden und Properties ....

- können Arrays sein
  int[], String[]
  
  Arrays haben auch Methoden und Properties ....
    x.length <- Property "length" vom Array "x"
    Property ist eine Art "Untervariable" :-/

Arrays:
-------
  - Enthalten mehrere Werte
  - Können ihrerseits wie Variablen benutzt werden
    (d.h. an Funktionen übergeben und zurück gegeben)
  - Wenn wir einen der Werte eines Arrays nutzen wollen,
    muss, die Position / der Index angegeben werden
    x[0], x[1], ... werden zu Werten evaluiert
                (Positionen des Arrays)
    x ist das Array mit mehreren Werten
    
Schlüsselworte der Programmiersprache:
--------------------------------------
for, while ... für Schleifenkonstrukte
if, else ... Fallunterscheidung / Verzweigung / Branching
return ... am Ende einer Funktion, um einen Wert zurück
           zu geben
new ... benutzen wir überall, wo neue Arrays
        (später auch Objekte) erzeugt werden
        hängt mit dem Speichermanagement des
        Betriebssystems zusammen
        
API Funktionen:
---------------
Vordefinierte Funktionen, die wir im Umfang der
Programmiersprache erwarten, die aber keine
Schlüsselworte sind.
z.B.
  Math.random()
  System.out.println()
  
Operatoren:
-----------
teil der Programmiersprachen-Syntax
  +
  -
  *
  /
  
  ==  Vergleich
  !=  ...
  <=
  >=
  
  = Zuweisung
  
.... noch etliche mehr!

Syntax:
-------
 = "Formaler Aufbau des Programmcodes"
 
 z.B.
 geschweifte Klammern {}
 um Instruktionen zusammen zu gruppieren
 
 Code innerhalb einer Funktion steht in {}
 Code in einem Schleifenkörper steht in {}
 Code in einer if / else - Verzweigung ...
 Mit der schließenden geschweiften Klammer endet
 entsprechend die Funktion, oder die Schleife, oder
 die Verzweigung, ...
 
 
 
Arrays im Arbeitsspeicher
=========================
Speicher: ###############################
          _int_int_arr   _+++++++++++++++
          ^   ^   ^      ^-Array-Werte
          |   |   |Referenz auf Array Werte
          |   |Integer-Wert
          |Integer-Wert
          
          Funktionsadresse: #############
                            _int
                            ^-Integer-Wert wird in
                              Funktionsspeicher kopiert
                              
funktion( kriegt eine kopie des übergebenen Wertes )

  Funktionsadresse (array): #############
                            _arr
                            ^-Array-Referenz wird in
                              Funktionsspeicher kopiert
                              (aber nicht Array-Werte!)
                            
funktion( kriegt eine Kopie der Arrayreferenz / Pointer )
          Diese Referenz / Pointer verweist auf die
          selben Arraydaten, wie in dem aufrufenden
          Programm